#pragma once

#include <iostream>
#include <ctime> // #include <time.h>
#include <string>
#include <cstring>
#include <vector>
#include <cassert>
#include <functional>
#include <unordered_map>
#include <pthread.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <typeinfo>
#include <memory>
#include <fcntl.h>
#include <signal.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

// using namespace std;

/////////////////////////////////////////////////////////////////    日志模块  //////////////////////////////////////////////////////////////////////////////////////
#define INT 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG // 设置的日志等级

// #define LOG(format, ...) fprintf(stdout, "[%s:%d]" format "\n", __FILE__, __LINE__, __VA_ARGS__);
#define LOG(level, format, ...)                                                                                      \
    do                                                                                                               \
    {                                                                                                                \
        if (level < LOG_LEVEL)                                                                                       \
            break;                                                                                                   \
        time_t t = time(NULL);                                                                                       \
        struct tm *ltm = localtime(&t);                                                                              \
        char timeBuffer[32] = {0};                                                                                   \
        strftime(timeBuffer, sizeof(timeBuffer) - 1, "%H:%M:%S", ltm);                                               \
        fprintf(stdout, "%p [%s %s:%d]" format "\n", pthread_self(), timeBuffer, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)

// 有对上面的 LOG 宏函数再封装的感觉
#define INT_LOG(format, ...) LOG(INT, format, ##__VA_ARGS__);
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__);
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__);

// pthread_t pthread_self(void)  // 获取当前线程的 id
// std::this_thread::get_id()    // 也是可以的

///////////////////////////////////////////////////////   用户层面的接收缓冲区      ///////////////////////////////////////////////////////
// 注意tcp的缓冲区和这里的Buffer之间的联系
#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer;
    uint64_t _reader_idx;
    uint64_t _writer_idx;

public:
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    // 下面为什么不能直接返回 _buffer.begin(); 呢？
    // _buffer.begin() 返回的是迭代器，解引用才是指向空间起始位置的数据，再取地址才是指向起始空间的地址
    char *Begin() { return &*_buffer.begin(); }
    // 获取当前写入起始地址，_buffer的空间的起始地址，加上写偏移量
    char *WritePosition() { return Begin() + _writer_idx; }
    // 获取当前读取的起始地址
    char *ReadPosition() { return Begin() + _reader_idx; }
    // 获取缓冲区末尾空闲空间大小 -- 写偏移之后的空闲空间，总体空间大小减去写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取缓冲区起始空闲空间的大小 -- 读偏移之前的空闲空间大小
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据端的大小
    uint64_t ReadAbleSize() { return _writer_idx - _reader_idx; }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后移动的大小必须小于可读空间的大小
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 写偏移向后移动的大小必须得小于当前后边的空闲空间的大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空闲空间足够（整体空闲空间足够了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        // 如果末尾空闲空间足够的话，直接返回（可以直接写入）
        if (TailIdleSize() >= len)
            return;
        // 末尾空闲空间不够，则判断加上起始空闲空间的大小是否足够，够了就移动数据。不够就扩容
        if (len <= TailIdleSize() + HeadIdleSize())
        {
            // 将数据移动到起始位置
            uint64_t rsz = ReadAbleSize();
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
            _reader_idx = 0;
            _writer_idx = rsz;
        }
        else
        {
            DBG_LOG("RESIZE %ld", _writer_idx + len);
            _buffer.resize(_writer_idx + len);
        }
    }
    // 写入数据（把 data 里面的 len 长度的数据写入到我们的 _buffer 中）
    void Write(const void *data, uint64_t len)
    {
        // 1. 保证有足够的空间    2. 拷贝数据进去
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteString(const std::string &data)
    {
        return Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        // 从 const std::string& data; 中写入数据的大小也就是 data.size(), 所以下面的 _Writer_idx 移动的长度就是 data.size() 的大小咯
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBuffer(Buffer &data)
    {
        return Write(data.ReadPosition(), data.ReadAbleSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        // 从 Buffer& data; 中写入数据的大小也就是 ReadAbleSize(), 所以下面的 _Writer_idx 移动的长度就是 data.ReadAbleSize() 的大小咯
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        // 要求获取数据的大小必须小于可读空闲空间的大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsString(uint64_t len)
    {
        // 要获取的数据大小必须小于可读数据的大小
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    // 找到 \n ---> 每一次读取一行数据
    char *FindCRLF()
    {
        // void *memchr(const void *s, int c, size_t n);
        // memchr 函数的作用就是在一段字符区间内找到一个字符
        char *res = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }
    //
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
            return "";
        // +1 是为了把后面的换行符也取出来
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清空缓冲区
    void Clear()
    {
        // 只需要将 _writer_idx 和 _reader_idx 偏移即可(数据是覆盖的)
        _writer_idx = _reader_idx = 0;
    }
};

//////////////////////////////////////////////     针对套接字 int _sockfd 的一系列管理(create,bind,listen,accept......)       //////////////////////////////////////////
#define MAX_LISTEN 1024
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }
    // 创建套接字
    bool Create()
    {
        // int socket(int domain, int type, int protocol)
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("CREATE SOCKET FATLED!!!");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint64_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int bind(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("BIND ADDRESS FAILED!!!");
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        // int listen(int backlog)
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ERR_LOG("SOCKET LISTEN FAILED!!!");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint64_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int connec(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("CONNECT SERVER FAILED!!!");
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        // int accept(int sockfd, struct sockaddr* addr, socklen_t len);
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            ERR_LOG("SOCKET ACCEPT FAILED!!!");
            return -1;
        }
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        // ssize_t recv(int sockfd, void* buf, size_t len, int flag);
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0) // ret == 0 的情况也是算进去的哦，因为一个连接在本应该发送数据期间被中断的时候，那么发送的数据就是 0 了
        {
            // EAGAIN 当前 socket 的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR 表示当前 socket 的阻塞等待，被信号打断了
            if (errno == EAGAIN || errno == EINTR)
                return 0; // 表示这次接收没有接收到数据
            ERR_LOG("SOCKET RECV FAILED!!!");
            return -1;
        }
        return ret;
    }
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        // ssize_t send(int sockfd, void* buf, size_t len, int flag);
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
                return 0;
            ERR_LOG("SOCKET SEND FAILED!!!");
            return -1;
        }
        return ret; // 实际发送数据的长度
    }
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        if (len == 0)
            return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT   表示当前发送为非阻塞
    }
    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务端连接
    bool CreateServer(uint64_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1. 创建套接字   2. 绑定地址   3. 开始监听   4. 设置非阻塞   5. 启动地址重用
        if (Create() == false)
            return false;
        if (block_flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        ResueAddress();
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint64_t port, const std::string &ip)
    {
        // 1. 创建套接字   2.指向连接服务器
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字选项 --- 开启地址端口复用
    void ResueAddress()
    {
        // int setsockopt(int fd, intlevel, int optname, void* val, int vallen);
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
    }
    // 设置套接字阻塞属性 --- 设置为非阻塞
    void NonBlock()
    {
        // int fcntl(int fd, int cmd, .../* arg */);
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};

////////////////////////////////////////////////////////////    对单个文件描述符事件管理以及事件的处理的     ////////////////////////////////////////////////////////////
class Poller;
class EventLoop;
class Channel
{
private:
    int _fd; // 外部传递进来的，需要管理的描述符
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数

public:
    Channel(EventLoop *loop, int fd) : _fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; }
    uint32_t Events() { return _events; }
    void SetREvents(uint32_t events) { _revents = events; }
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 判断当前是否监控了可读
    bool ReadAble() { return _events & EPOLLIN; }
    // 判断当前是否监控了可写
    bool WriteAble() { return _events & EPOLLOUT; }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭是有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 移除监控(后面会调用EventLoop接口来移除，EventLoop里面有Poller,Poller监控多个channel)
    // 虽然channel最终是和EventLoop整合的，也可以先和poller测试一下。因为毕竟EventLoop里面用的还是poller
    void Remove();
    void Update();
    // 事件处理，一旦连接触发了事件，就调用这个函数，自己触发了什么事件如何处理自己决定
    void HandleEvent()
    {
        // 下面是一个段错误的示例： Segmentation fault
        // 1. 下面各种回调函数的情况中，因为 _read_callback(), _write_callaback(), _error_callback, _close_callback() 都可能会造成 delete channel, 所以 _event_callback() 放在前面打印了。
        // 2. 下面的各种情况如果不用 if, else if, else if.... 只能执行一个的话，是会出现段错误的（找了好久的报错，不过这样，代码上和标准的代码有些出入了。但是功能上好像没有问题）
        // 用下面注释的写法的话，是会有段错误的。但是标准的写法应该是下面的这种写法
        // if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
        //     /*不管任何事件，都调用的回调函数*/
        //     if (_read_callback) _read_callback();
        // }
        //
        // /*有可能会释放连接的操作事件，一次只处理一个*/
        // if (_revents & EPOLLOUT) {
        //     if (_write_callback) _write_callback();
        // }else if (_revents & EPOLLERR) {
        //     if (_error_callback) _error_callback();// NOTE(zhangshuancheng)一旦出错，就会释放连接，因此要放到前边调用任意回调
        // }else if (_revents & EPOLLHUP) {
        //     if (_close_callback) _close_callback();
        // }
        //
        // if (_event_callback) _event_callback();

        // 下面的 std::cout 为找错误时候的打印调试信息的
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            if (_event_callback)
                _event_callback();
            // 不管任何事件都调用的回调函数
            if (_read_callback)
                _read_callback();
        }

        // 测试后面的 Class Connection 的时候，这里不用 else if 反而是没有什么问题的
        if (_revents & EPOLLOUT) // 可能会触发连接操作事件，一次只处理一个的哦
        {
            // std::cout << 1 << std::endl;
            if (_event_callback)
                _event_callback(); //  Segmentation fault
            if (_write_callback)
            {
                // std::cout << 11 << std::endl;
                _write_callback();
            }
        }
        else if (_revents & EPOLLERR)
        {
            // std::cout << 2 << std::endl;

            if (_event_callback)
                _event_callback();
            // 一旦出错，就会释放连接，因此要放到前边调用任意回调
            if (_error_callback)
                _error_callback();
        }
        else if (_revents & EPOLLHUP) // epollhub 表示的是对方挂断连接的意思
        {
            // std::cout << 3 << std::endl;

            if (_event_callback)
                _event_callback();
            if (_close_callback)
                _close_callback();
        }
        // else if (_event_callback)
        //     _event_callback();
    }
};

/////////////////////////////////////////////////  对多个描述符int _sockfd(channel)的管理   /////////////////////////////////////////////////
// 其中的 _epfd 用来管理多个描述符
// Poller 英文的翻译结果是轮询器
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;

private: // 实现对外提供的接口的辅助接口
    // 对 epoll 的直接操作
    // Channel里面有文件描述符和对应的操作事件，所以传个Channel就可以了。
    void Update(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op, int fd, struct eoll_event* ev);
        // epoll_ctl 对Chennal里面的文件描述符的操作(增，删，改)
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
            ERR_LOG("EPOLLCTL FAILED!!!");
        return;
    }
    // 判断一个 channel 是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
            return false;
        return true;
    }

public: // 对外提供的
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS); // 传递的餐宿没什么用，大于0就可以了
        // std::cout << "_epfd: " << _epfd << std::endl;
        if (_epfd < 0)
        {
            ERR_LOG("EPOLL CREATE FAILED!!!");
            abort(); // 退出程序
        }
    }
    // 添加或修改监控事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 不存在 unordered_map 里面，注意unordered_map和epoll里面都得添加的哦
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除监控事件
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            // _channels.erase(channel->Fd());
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃连接
    void Poll(std::vector<Channel *> *active)
    {
        // int epoll_wait(int epfd, struct epoll_event* evs, int maxevents, int timeout);
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1); // -1 表示的是阻塞式的 epoll_wait 的哦
        if (nfds < 0)
        {
            if (errno == EINTR)
                return;
            ERR_LOG("EPOLL WAIT ERROR: %s\n", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            // _evs[i].data.fd表示我能够对一个描述符进行事件监控(现在能够就绪事件了)，那么这个文件描述符必然是存在我所管理的_chennal的。不存在，那么我的管理_chennal有问题。
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置实际的就绪事件
            active->push_back(it->second);
        }
        return;
    }
};

// 下面的这两个函数因为使用了 class EventLoop 类里面的成员，所以放在跟下面的位置是更加保守的哦
// void Channel::Remove() { return _loop->RemoveEvent(this); }
// void Channel::Update() { return _loop->UpdateEvent(this); }

//////////////////////////////////////////////////////////     定时任务模块      ///////////////////////////////////////////////////////////
using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{
private:
    uint64_t _id;
    uint32_t _timeout;
    bool _canceled;
    TaskFunc _task_cb;
    ReleaseFunc _release;

public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb) : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
    ~TimerTask()
    {
        // 任务没有取消的情况下才执行的哦
        if (_canceled == false)
            _task_cb();
        _release();
    }
    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }
};

////////////////////////////////////////////////////////////   时间轮在不停的转(在不停的执行任务)    ////////////////////////////////////////////////////////////
class EventLoop;
class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>;  // 没有引用计数的
    using PtrTask = std::shared_ptr<TimerTask>; // 有引用计数的
    int _tick;                                  // 当前秒针，走到哪里释放哪里，释放哪里，就相当于是执行哪里的任务的哦
    int _capacity;                              // 表盘的最大容量 --- 其实就是最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers;

    EventLoop *_loop; // 一个定时器对应一个线程（每一个线程里面都有一个定时器）
    int _timerfd;     // 定时器描述符  ---- 可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;

private:
    // 移除定时任务
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            // _timers.erase(id);  // 不应该是移除 id 的吗
            _timers.erase(it);
        }
    }
    // 创建 timerfd 定时器描述符
    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            ERR_LOG("TIMERFD CREATE FAILED!!!");
            abort(); // 直接退出程序
        }
        // int timerfd_settime(int fd, int flags, struct itimerspec* lod);
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 第一次超时时间为 1s 后
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0; // 第一次超时后，每一次超时的时间间隔
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }
    // 读取定时器
    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其它描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            ERR_LOG("READ TIMERFD FAILED!!!");
            abort(); // 直接退出程序
        }
        return times;
    }
    // 这个函数应该每一秒针被执行一次，相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的是有管理定时器对象的shared_ptr释放掉
    }
    // TimerWheel 触发了设置的可读事件就会执行的函数(我感觉是添加了定时任务的时候就会触发下面的可读事件)
    void OnTime()
    {
        // 根据实际超时的次数，执行对应的超时任务
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
        {
            RunTimerTask();
        }
    }

    // TimerWheel 与 EventLoop 的整合：
    // EventLoop* _loop; 对应的线程里面要添加定时任务(定时任务都在TimerWheel里面，EventLoop里面是没有存储定时任务的。但是有)
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt); // 注意 shared_ptr 得配合 weak_ptr 的使用方式
    }
    // EventLoop* _loop; 对应的线程里面要刷新定时任务(定时任务都在TimerWheel里面，EventLoop里面是没有存储定时任务的)
    void TimerRefreshInLoop(uint64_t id)
    {
        // 没找着定时任务，没法刷新，没法延迟的哦
        auto it = _timers.find(id);
        if (_timers.end() == it)
            return;

        // weak_ptr 对象.lock() 就得到了 对应的 shared_ptr 了哦，因为得用 shared_ptr 来操作数据的哦
        PtrTask pt = it->second.lock();
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    // EventLoop* _loop; 对应的线程里面要取消定时任务(定时任务都在TimerWheel里面，EventLoop里面是没有存储定时任务的)
    // 注意 Timertask 在这里的存储结构的哦。不能是不能从二维数组中移除的哦，因为二维数组中的每一个元素是一个一维数组，这里一维数组中的所有的元素都在相同的时间被执行的。
    // 所以是不好把 uitn64_t id 这个 TimerTask 从二维数组中移除的，不过从 _timers 中移除还是好操作的
    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
            return;

        PtrTask pt = it->second.lock();
        if (pt != nullptr)
            pt->Cancel();
    }

public:
    TimerWheel(EventLoop *loop) : _capacity(60), _tick(0), _wheel(_capacity), _loop(loop),
                                  _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead(); // 启动读事件监控
    }
    // 定时器中有个 _timers 成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全的问题
    // 如果不想加锁，那就把对定期的所有的操作，都放到一个线程中进行
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);

    // 这个接口存在线程安全的问题  --- 这个接口实际上不能被外界使用者调用，只能在模块内，EventLoop对应的线程内执行
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
            return false;
        return true;
    }
};

///////////////////////////////////////////////////////////    一个线程一个EventLoop  ///////////////////////////////////////////////////////////
// 进行事件监控，以及事件处理的模块（关键点：这个模块与线程是一一对应关联的）
class EventLoop
{
private:
    std::thread::id _thread_id;              // 线程 id（一个EventLoop对应一个线程）
    int _event_fd;                           // eventfd唤醒IO事件监控有可能导致的阻塞情况（导致下面的任务队列里面的任务不能被执行的情况）
    std::unique_ptr<Channel> _event_channel; // 对上面的 _event_fd 描述符进行事件管理
    // poller 是所有的描述符进行IO事件监控
    Poller _poller; // error： 进行所有连接当前线程的描述符，的事件管理（对多个描述符int _sockfd(channel)的管理）
    using Functor = std::function<void()>;
    // 为什么要设置一个任务队列池？
    // 这个任务队列，是为了保证对每个描述符的操作都放在同一个线程内部进行，避免出现线程安全问题
    std::vector<Functor> _tasks; // 任务队列池(下面是_tasks.swap(functor);所以没用队列了，相对于是一个队列)

    std::mutex _mutex; // 实现任务池操作的线程安全

    TimerWheel _timer_wheel; // 定时器模块
private:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        // 把下面的 _mutex 形成一个局部区域
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }
        for (auto &it : functor)
            it();
        return;
    }
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            ERR_LOG("CREATE EVENTFD FAILED!!!");
            abort(); // 让程序异常退出
        }
        return efd;
    }
    void ReadEventfd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            // EINTR 表示的是被信号打断， EAGAIN 表示的是无数据可读
            if (errno == EINTR || errno == EAGAIN)
                return;
            ERR_LOG("RETURN EVENTFD FAILED");
            abort();
        }
        return;
    }
    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
                return;
            ERR_LOG("READ EVENTFD FAILED!!!");
            abort();
        }
        return;
    }

public:
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreateEventFd()),
                  _event_channel(new Channel(this, _event_fd)),
                  _timer_wheel(this)
    {
        // 给 _event_fd添加可读事件回调函数，读取eventfd事件通知的次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }
    // 三步走：事件监控--》就绪事件处理--》执行任务
    void Start()
    {
        while (true)
        {
            // 1. 事件监控
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            // 2. 事件处理
            for (auto &channel : actives)
                channel->HandleEvent();
            // 3. 执行任务
            RunAllTask();
        }
    }
    // 用于判断当前线程是否是EventLoop对应的线程
    bool IsInLoop()
    {
        // std::this_thread::get_id(); 表示的是当前正在执行函数(任务)的线程id
        return _thread_id == std::this_thread::get_id();
    }
    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }
    // 判断将要执行的任务是否处于当前线程中。如果是则执行，不是则压入队列（至于当前执行的任务是哪一个文件描述符触发的不用管）
    void RunInLoop(const Functor &cb)
    {
        // std::cout << "当前线程id: " << _thread_id << "    " << "执行线程id: " << std::this_thread::get_id() << std::endl;
        DBG_LOG("RunInLoop: 当前线程id: %p    执行线程id: %p\n", _thread_id, std::this_thread::get_id());
        bool ret = IsInLoop();
        if (ret == true)
        {

            return cb();
        }
        // client新连接的事件执行都得先经过这个函数。
        // 【一个连接的所有的操作都得在一个线程中执行。防止线程安全问题。】
        // 【是最开始的时候是主线程执行这个连接的这个函数(client还没有被poller监控呢，怎么执行任务调用这个函数呢？所以得主线程来执行)，不是这个连接绑定的线程执行的。】
        // (虽然说所有client新连接的挂到poller上被监控事件是主线程执行的，但是主线程只有一个是不会有线程安全问题的)
        // 1. 主从线程之间的交互场景：
        //    实际的场景执行流：
        //          主线程在获取新连接之后为新连接创建Connection,并把新连接挂到绑定线程的poller上被监控。
        //          把新连接挂到绑定线程的poller上被监控应该是在当前线程中完成的，但是新连接的套接字还没有被监控呢，所以由主线程来执行了。
        //          这是唯一的一次主从线程之间的交互场景，因为主线程也只需要为新连接的从属线程执行这一次。主线程的任务只是执行TcpServer模块里面NewConnection函数这一个执行流。
        //    打印现象：
        //          所以我们上面打印这个函数实际是那个线程执行的id和实际执行这个函数的线程id：可以看到只有第一次是主线程执行，之后都是绑定的从属线程在执行。
        // 2. 从属线程之间的交互场景：
        //    实际的场景执行流：
        //          目前来说就这个服务器内部每个连接的操作都是在自己所属的eventloop线程内部进行操作的，
        //          但是到真正使用的时候，可能会在用户自己创建的线程内对connection进行操作，这时候就涉及到线程安全的问题了
        //
        //    打印现象：(看下面的广播的场景，应该是得有多个client)
        //          比如有个聊天应用，用户会自己把每个connection自己保存一份，当一个connection发来消息，则广播给其他的connection，这时候广播的时候，就跨执行流了，存在线程安全的问题
        //
        return QueueInLoop(cb);
    }
    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞
        // 其实就是给_event_fd写入一个数据，eventfd就会触发可读事件
        // eventfd又是EventLoop对象在实例化的时候在构造函数里面就会挂到poller上被监控，所以eventfd触发了可读事件就会被poller监控到，上面的Start函数就动起来了，就会执行任务队列里面的任务。
        WeakUpEventFd();
    }

    // Poller _poller; 线程的描述符管理模块：
    // 用于添加/修改描述符的事件监控
    void UpdateEvent(Channel *channel)
    {
        return _poller.UpdateEvent(channel);
    }
    // 移除描述符的监控
    void RemoveEvent(Channel *channel)
    {
        return _poller.RemoveEvent(channel);
    }

    // TimerWheel 定时器模块：
    // 添加定时任务
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        return _timer_wheel.TimerAdd(id, delay, cb);
    }
    // 更新(延迟)定时任务
    void TimerRefresh(uint64_t id)
    {
        return _timer_wheel.TimerRefresh(id);
    }
    // 取消定时任务
    void TimerCancel(uint64_t id)
    {
        return _timer_wheel.TimerCancel(id);
    }
    // 是否存在某个定时任务
    bool HasTimer(uint64_t id)
    {
        return _timer_wheel.HasTimer(id);
    }

    // 做实验想得到这个线程的线程id，所以提供了下面的这个函数，用来访问私有成员std::thread::id _thread_id;得到线程id (不过好像不行)
    // pthread_t get_conn_thread()
    // {
    //     return _thread_id;
    // }
};

//////////////////////////////////////////////////////////     //////////////////////////////////////////////////////////
// 线程和EventLoop模块的整合(先创建线程，再实例化线程对应的EventLoop)
class LoopThread
{
private:
    // 先创建线程，再创建线程对应的 EventLoop
    // 注意理解：用于实现 _loop 获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop
    std::mutex _mutex;             // 互斥锁(互斥锁使用的时候一般会用一个大括号来限定作用域的哦)
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // EventLoop 指针变量，这个对象需要在线程内实例化，EventLoop对象的线程id得是当前线程的id，所以得先有线程(所以不能定义一个EventLoop对象)
    std::thread _thread;           // EventLoop 对应的线程

private:
    // 实例化 EventLoop 对象，唤醒 _cond 上有可能阻塞的线程，并且开始运行EventLoop模块的功能
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _loop = &loop;
            // 下面的 GetLoop 函数阻塞了，在这里创建的时候就得通知它们的哦
            _cond.notify_all();
        }
        // 虽然上面创建的 EventLoop loop;是一个局部变量，但是下面的loop.Start()函数是一个死循环。是不会退出的，所以不用但是EventLoop loop局部变量会销毁的情况
        // 这也是 one thread one loop 的精义吧!!!
        loop.Start();
    }

public:
    // 创建线程，设定线程入口函数
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    // 返回当前线程关联的EventLoop对象指针
    EventLoop *GetLoop()
    {
        EventLoop *loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            // 条件变量后面的判断条件一般是一个函数，函数(一般是一个lambda表达式)的返回值是一个bool值
            _cond.wait(lock, [&]()
                       { return _loop != nullptr; });
            loop = _loop;
        }
        return loop;
    }
};

//////////////////////////////////////////////////////////         //////////////////////////////////////////////////////////
// 管理多个线程(LoopThread，LoopThread里面是有线程和线程对应的EventLoop的哦)
class LoopThreadPool
{
private:
    // _thread_count 表示的是线程的个数，由用户输入。因为有可能是0(这种情况主线程的baseloop一个人承担了获取新连接和所有的业务处理)
    // _thread_count > 0 的时候会有从属线程，baseloop就可以把业务处理部分分配给从属线程了(所以需要传递外面的 baseloop 进来的哦)
    int _thread_count;
    int _next_idx;
    EventLoop *_baseloop;
    // 线程(因为我们使用的是 new LoopThread(); 来创建 LoopThread 从属线程对象的。所以这里封装的线程池/线程数组的元素类型是LoopThread*的)
    // 更重要的原因是因为我们要的是一个全局属性的线程，在别的类里面得使用的。创建局部LoopThread的话是没法传递出去的。
    std::vector<LoopThread *> _threads;
    // 每一个线程里面对应的EventLoop*(其实也是可以使用上面的 _threads 数组的，这里可能是为了代码编写的简洁吧)
    std::vector<EventLoop *> _loops;

public:
    LoopThreadPool(EventLoop *baseloop) : _baseloop(baseloop),
                                          _thread_count(0),
                                          _next_idx(0) {}
    void SetThreadCount(int count) { _thread_count = count; }
    void Create()
    {
        if (_thread_count == 0)
            return; // 用户输入创建从属线程数量为0的情况
        //
        _threads.resize(_thread_count);
        _loops.resize(_thread_count);
        for (int i = 0; i < _thread_count; i++)
        {
            _threads[i] = new LoopThread();
            _loops[i] = _threads[i]->GetLoop(); // 存储线程对应的 EventLoop*
        }
        return;
    }
    EventLoop *GetNextLoop()
    {
        if (_thread_count == 0)
            return _baseloop; // 没有从属线程的情况下 baseloop 线程承担所有的业务处理的
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }
};

//////////////////////////////////////////////////////////         //////////////////////////////////////////////////////////
// C++17标准库里面也是有实现的(用的时候得 g++ -g test.cc -o test -std=c++17, #include <any>)
class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info &type() { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() { return new placeholder(_val); }

    public:
        T _val;
    };
    holder *_content;

public:
    Any() : _content(NULL) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &other) : _content(other._content ? other._content->clone() : NULL) {}
    ~Any() { delete _content; }

    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template <class T>
    T *get()
    {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }
    // 赋值运算符的重载函数
    template <class T>
    Any &operator=(const T &val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }
    Any &operator=(const Any &other)
    {
        Any(other).swap(*this);
        return *this;
    }
};

//////////////////////////////////////////////////////////      //////////////////////////////////////////////////////////
// 对连接进行全方位的管理，对通信连接的<所有操作>都是通过这个模块提供的功能完成。
class Connection;
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
    // uint64_t _timer_id; // 定时器ID,必须是唯一的，这块为了简化操作使用_conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false
    EventLoop *_loop;              // 连接所关联的一个EventLoop
    ConnStatu _statu;              // 连接状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区 --- 存放从 socket 中读取到的数据
    Buffer _out_buffer;            // 输出缓冲区 --- 存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文

    // 这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）
    // 换句话说，这几个回调函数都是组件使用者使用的
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    // 新连接创建成功后可以立即处理的任务（例如广播一下，有一个新用户加入了）
    ConnectedCallback _connected_callback;
    // client(新连接)向server发送信息的时候会触发下面的函数，server就执行下面的函数对client发送过来的数据进行业务处理
    // 描述符(新连接)可读事件被触发后会调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
    MessageCallback _message_callback;
    // 任意事件回调(想在哪里执行就执行的回调函数，感觉相当于是一个DBG_LOG)
    AnyEventCallback _event_callback;
    // 这个关闭连接回调函数是用户设置的
    ClosedCallback _closed_callback;
    // 下面的关闭函数是TcpServer设置的，用来移除服务器管理的连接信息
    // 组件内的连接关闭回调 -- 组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭，就应该从管理的地方移除掉自己的信息。
    // 从class TcpServer创建对象中的std::unordered_map<uint64_t, PtrConnection> _conns;中移除。相对于是释放了Connection。
    // 注意从_conns中erase了就没了，因为连接的所有操作都是在通过Connection模块提供的功能完成的。先从_conns中移除的话，只是我们的TcpServer中没有了这个新连接的记录了。
    // 但是我们新连接还是没有从监控它的线程中移除监控的，所以还得操作这个连接执行一些事情的。先从TcpServer中移除的话，这个连接就不能执行任何操作了。
    // 所以得先调用用户设置的关闭连接的回调函数(上面的_closed_callback)，再调用下面的_server_closed_callback。
    ClosedCallback _server_closed_callback;

private:
    // 五个channel的事件回调函数

    // 描述符可读事件触发后会调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
    void HandleRead()
    {
        // 1. 接收socket的数据，放到缓冲区中
        char buffer[65536];
        ssize_t ret = _socket.NonBlockRecv(buffer, sizeof(buffer) - 1);
        if (ret < 0)
        {
            // 出错了，不能直接关闭连接
            return ShutdownInLoop();
        }
        // 这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
        // 将数据放入到输入缓冲区
        _in_buffer.WriteAndPush(buffer, ret);
        // 2. 调用_message_callback进行业务处理
        if (_in_buffer.ReadAbleSize() > 0)
        {
            // shared_from_this --- 从当前对象自身获取的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }
    // 描述符可写事件触发后调用的函数，接收发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        // _out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0)
        {
            // 发送错误就关闭连接了
            if (_in_buffer.ReadAbleSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            // 这时候就是实际的关闭释放操作了
            return Release();
        }
        _out_buffer.MoveReadOffset(ret); // 不要忘记将读偏移向后移动的哦
        if (_out_buffer.ReadAbleSize() == 0)
        {
            // 没有数据发送了,就得关闭写事件监控
            _channel.DisableWrite();
            if (_statu == DISCONNECTING)
                return Release();
        }
        return;
    }
    // 描述符触发挂断事件
    void HandleClose()
    {
        // 一旦连接挂断了,套接字就什么都干不了了,因此有数据待处理就处理一下,完毕关闭连接
        if (_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }
    // 描述符触发出错事件
    void HandleError()
    {
        return HandleClose();
    }
    // 描述符触发任意事件: 1. 刷新连接的活跃度 --- 延迟定时销毁任务; 2. 调用组件使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
            _loop->TimerRefresh(_conn_id);
        if (_event_callback)
            _event_callback(shared_from_this());
    }

    // 获取连接后，所处的状态下要进行各种设置（给channel设置事件回调，启动读监控）
    void EstablishedInLoop()
    {
        // 1. 修改连接状态   2. 启动读事件监控  3. 调用回调函数
        assert(_statu == CONNECTING); // 当前的状态必须是上一层的半连接状态
        _statu = CONNECTED;           // 当前函数执行完毕,则连接进入已完成连接状态
        // 一旦启动读事件监控有可能会立即触发读事件,如果这个时候启动了非活跃连接销毁
        _channel.EnableRead();

        // 新连接创建成功后可以立即处理的任务（例如广播一下，有一个新用户加入了）
        // 这也是TcpServer模块里面为什么用unordered_map管理所有client对应的Connection的一个简单应用
        // 不过这里好像并没有广播到其它所有的client
        if (_connected_callback)
            _connected_callback(shared_from_this());
    }
    // 这个接口才是实际的释放接口
    void ReleaseInLoop()
    {
        // 1. 修改连接状态,将其置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭描述符
        _socket.Close();
        // 4. 如果当前定时器队列中还有定时销毁任务,则取消任务
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();
        // 5. 调用关闭回调函数,避免先移除服务器管理的连接信息导致Connection被释放,再去处理会出错,因先调用用户的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }
    // 这个接口并不是实际的发送接口,而只是把数据放到了发送缓冲区,启动了可写事件监控
    // void SendInLoop(const char *data, size_t len)
    // {
    //     if (_statu == DISCONNECTED)
    //         return;
    //     _out_buffer.WriteAndPush(data, len);
    //     if (_channel.WriteAble() == false)
    //         _channel.EnableWrite();
    // }
    void SendInLoop(Buffer &data)
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(data);
        if (_channel.WriteAble() == false)
            _channel.EnableWrite();
    }
    // 这个关闭操作并非实际的连接释放操作,需要判断还有没有数据待处理,待发送
    void ShutdownInLoop()
    {
        _statu = DISCONNECTING; // 设置连接为半关闭状态
        if (_in_buffer.ReadAbleSize() > 0)
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        // 要么就是写入数据的时候出错关闭,要么就是没有待发送数据,直接关闭
        if (_out_buffer.ReadAbleSize() > 0)
            if (_channel.WriteAble() == false)
                _channel.EnableWrite();
        if (_out_buffer.ReadAbleSize() == 0)
            Release();
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1. 将判断标志 _enable_inactive_release 置为 true
        _enable_inactive_release = true;
        // 2. 如果当前定时销毁任务已经存在,那就刷新延迟一下即可
        if (_loop->HasTimer(_conn_id))
            return _loop->TimerRefresh(_conn_id);
        // 3. 如果不存在定时销毁任务,则新增
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
            _loop->TimerCancel(_conn_id);
    }
    void UpgradeInLoop(const Any &context,
                       const ConnectedCallback &conn,
                       const MessageCallback &msg,
                       const ClosedCallback &closed,
                       const AnyEventCallback &event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _loop(loop), _conn_id(conn_id), _sockfd(sockfd),
                                                                _enable_inactive_release(false), _statu(CONNECTING),
                                                                _socket(sockfd), _channel(loop, _sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }

    ~Connection() { DBG_LOG("RELEASE CONNECTION: %p", this); }
    // 获取管理的文件描述符
    int Fd() { return _sockfd; }
    // 获取连接ID
    int Id() { return _conn_id; }
    // 是否处于CONNECTED状态
    bool Connected() { return _statu == CONNECTED; }
    // 设置上下文 --- 连接建立完成时进行调用
    void SetContext(const Any &context) { _context = context; }
    // 获取上下文 --- 返回的是指针
    Any *GetContext() { return &_context; }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }

    // 只有这一个函数是主线程用的（设置新连接被poller监控）
    // 连接建立就绪后,进行channel回调设置,启动读监控,调用_connected_callback
    void Established()
    {
        // std::cout << "启动conn的线程: " << std::this_thread::get_id() << std::endl;
        // 下面的 _loop 是TcpServer里面的线程池分配的，因为线程池线程数量可能为0，所以下面的 _loop 可能是主线程的 EventLoop 也可能是从属线程的 EventLoop
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }

    // 下面的公有函数都是从属线程用的
    // 发送数据,将数据放到发送缓冲区,启动写事件监控
    void Send(const char *data, size_t len)
    {
        // 外界传入的data,可能是个临时的空间,我们现在只是把发送操作压入了任务池,有可能并没有被立即执行
        // 因此有可能执行的时候,data指向的空间有可能已经被释放了
        // _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, data, len));

        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口 --- 并不实际关闭,需要判断有没有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }

    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }

    // 启动非活跃销毁,并定义多长时间无通信就是非活跃,添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议 --- 重置上下文以及阶段性处理函数 ---- 而是这个接口必须在绑定的EventLoop线程中立即执行
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                 const ClosedCallback &closed, const AnyEventCallback &event)
    {
        _loop->AssertInLoop(); // 这个接口必须在绑定的EventLoop线程中立即执行。所以得用断言来判断，要么执行，要么不执行。
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

////////////////////////////////////////////////////////// 主reactor(EventLoop _baseloop)           //////////////////////////////////////////////////////////
// 整合使用Socket模块和Channel模块对**监听套接字**进行管理
class Acceptor
{
private:
    Socket _socket; // 用于创建监听套接字
    // Channel _channel; // 用于对监听套接字进行事件管理
    // 1. 是先初始化 _baseloop，后面再初始化 _channel 的哦。因为 _channel 的初始化得有 _baseloop
    // 2. 从 _baseloop 是
    EventLoop *_baseloop; // 用于对监听套接字进行事件监控
    Channel _channel;     // 用于对监听套接字进行事件管理

    // 新连接获取成功之后的回调函数
    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;

private:
    // 监听套接字的读事件回调处理函数 --- 获取新连接，调用 _accept_callback 函数进行新连接处理
    void HandleRead()
    {
        // std::cout << "主线程的_baseloop: " << _baseloop << std::endl;
        int newfd = _socket.Accept();
        if (newfd < 0)
            return;
        if (_accept_callback)
            _accept_callback(newfd);
    }
    // 我们的Acceptor模块的Socket _socket;对象是一个server。
    // 但是调用 CreateClient 的地方只有client.cc文件里有，监听套接字为client新连接创建Connection里面的Socket对象却没有CreateServer和CreateClient，好像只是使用这个套接字进行信息的收发。
    int CreateServer(int port)
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }

public:
    // 不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动
    // 否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏
    Acceptor(EventLoop *baseloop, int port) : _socket(CreateServer(port)), _baseloop(baseloop),
                                              _channel(baseloop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
    // 调用监听函数就是启动套接字的可读事件
    void Listen() { _channel.EnableRead(); }
};

//////////////////////////////////////////////////////////            //////////////////////////////////////////////////////////
// 整合上面已经封装的模块，实现一个简便易用的 class TcpServer
class TcpServer
{
private:
    uint64_t _next_id; // 这是一个自动增长的连接ID
    int _port;
    int _timeout;                                       // 这是非活跃连接的统计时间 --- 多长时间无通信就是非活跃连接
    bool _enable_inactive_release;                      // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                // 这是主线程的EventLoop对象，负责监听事件的处理
    Acceptor _acceptor;                                 // 这是监听套接字的管理对象
    LoopThreadPool _pool;                               // 这是从属EventLoop线程池(内部有LoopThread*数组,LoopThread有线程和线程对应的EventLoop)
    std::unordered_map<uint64_t, PtrConnection> _conns; // 保存管理所有连接对应的shared_ptr对象

    // 用户设置给TcpServer的四个回调函数
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    using Functor = std::function<void()>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

private:
    void RunAfterInLoop(const Functor &task, int dalay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, dalay, task);
    }
    // 为新连接构造一个Connection进行管理
    void NewConnection(int fd)
    {
        _next_id++;
        PtrConnection conn(new Connection(_pool.GetNextLoop(), _next_id, fd));
        conn->SetConnectedCallback(_connected_callback);
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetAnyEventCallback(_event_callback);

        // 下面的这个回调函数绑定的是TcpServer自己提供的RemoveConnection接口,用来从TcpServer里面管理所有的client新连接创建的Connection的一个unordered_map里面erase。
        // 注意：我们的PtrConnection是一个 shared_ptr管理的指针，所以从unordered_map里面erase的话(释放了)，TcpServer就找不到client新连接了。
        // 作用：管理所有client新连接的COnnection的作用：TcpServer可以找到所有连接到这个服务器的client连接
        //       (TcpServer线程就相当于是一个宿舍的管理员了。线程池里的线程相当于是宿舍里面房间的管理员。当然_thread_count == 0的时候，没有宿舍，就只有一个房间，TcpServer线程就是这个房间的管理员)
        //       (简单的一个应用 ---> 一个新连接来了的时候，我们的TcpServer主线程可以把这个client新连接到来的消息广播给所有client)
        //       (下面的这个回调函数是得由这个client新连接绑定的线程去调用。而不是调用上面的_loop线程池让每一个线程都广播下面这个函数，那设置回调干嘛，这其实也广播到别的房间了去了)
        //       (所以得通过下面conn->Established()调用的EstablishInLoop函数里面调用这个回调函数，因为conn->Established()这个执行流是TcpServer主线程的执行流，所以还是TcpServer主线程到房间里通知房间里所有client的)
        //
        //       再说了，client新连接的到来是TcpServer主线程最先知道的。那么怎么不由主线程告诉client新连接绑定的从属线程，再由这个房间的管理员广播呢？这样不是更好吗？
        //       其实也是可以的，因为client新连接绑定的从属线程上面已经知道了，是可以用上面绑定的从属线程来直接调用_connected_callback广播的。
        //       但是我们的client新连接还没有挂到绑定线程的poller上被监控呢(也就是client新连接还没有正式来到绑定线程管理的房间里)，所以按道理还是由宿舍管理员TcpServer线程来通过回调的方式广播。
        conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        // 启动非活跃超时销毁
        if (_enable_inactive_release == true)
            conn->EnableInactiveRelease(_timeout);

        // 主线程获取新连接，所以下面打印的一定是主线程的id
        // std::cout << "主线程id: " << std::this_thread::get_id() << std::endl;
        DBG_LOG("挂起client连接被监控的主线程id: %p\n", std::this_thread::get_id());
        conn->Established(); // 就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }
    void RemoveConnectionInLoop(const PtrConnection &conn)
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end())
            _conns.erase(it);
    }
    // 从管理Connection的_conns中移除连接信息
    void RemoveConnection(const PtrConnection &conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

public:
    TcpServer(int port) : _port(port),
                          _next_id(0),
                          _enable_inactive_release(false),
                          _acceptor(&_baseloop, port),
                          _pool(&_baseloop)
    {
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen(); // 将监听套接字挂到baseloop上
    }

    void SetThreadCount(int count) { return _pool.SetThreadCount(count); }

    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void EnableInactiveCallback(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start()
    {
        _pool.Create();
        _baseloop.Start();
        // Create 不能在构造函数里面执行的哦。
        // 因为执行构造函数的时候，用户还没有设置要创建从属线程的数量，那么初始值是0。
        // 后面如果使用的话，就越界访问了。据会出现段错误的哦。
    }
};

void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
// NOTE(zhangshuancheng)刷新/延迟定时任务
void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

//////////////////////////////////////////////////////////         //////////////////////////////////////////////////////////
// 功能：忽略SIGPIPE信号
class NetWork
{
public:
    NetWork()
    {
        DBG_LOG("SIGPIPE INIT");
        // 为什么要忽略SIGPIPE信号？：连接断开的时候，如果再发送数据，就会触发异常会有SIGPIPE信号的产生，会导致进程的退出
        signal(SIGPIPE, SIG_IGN);
    }
};
// 全局static对象和全局变量是程序最先执行的，main函数执行之前(或者说main中第一个用户语句执行之前)
// 区别局部static变量：局部的static变量只是初始化一次，具有全局的生命周期
// 就是用来调用上面的构造函数用的
static NetWork nw;

// 没有上面的 static NetWork nw，如果server主动断开连接再启动的话是有问题的：
// [trw@VM-4-5-centos echoserver]$ ./main
// 0x7fc566af2740 [23:26:26 ../server.hpp:252]BIND ADDRESS FAILED!!!
// main: ../server.hpp:1422: int Acceptor::CreateServer(int): Assertion `ret == true' failed.
// Aborted
// [trw@VM-4-5-centos echoserver]$ netstat -natu | grep 8500
// tcp        0      0 127.0.0.1:8500          127.0.0.1:42766         TIME_WAIT
// 得过一段时间才能重新启动服务器
